home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / MOS / MOREIO.I < prev    next >
Encoding:
Modula Implementation  |  1990-11-10  |  18.0 KB  |  605 lines
  1. IMPLEMENTATION MODULE MoreIO;
  2. (*$B+,R-,S-*)
  3.  
  4. (* ----------------------------------------------------------------------------
  5.  * AUTOR:    Dieter Hametner und Thomas Tempelmann.
  6.  * ERSTELLT: 01.04.90 mit Megamax Modula-2 V2.2
  7.  * ----------------------------------------------------------------------------
  8.  * Treibermodul.
  9.  *
  10.  * Näheres siehe Definitions-Text
  11.  *
  12.  * Durch Setzen von 'ConfirmClose' auf FALSE wird erreicht, daß
  13.  * beim Ende des damit gelinkten Programms nicht mehr die Meldung
  14.  * '- END -' ausgegeben und auf einen Tastendruck gewartet wird.
  15.  *)
  16.  
  17. FROM SYSTEM     IMPORT  LONGWORD,       ADDRESS;
  18. IMPORT  Terminal,
  19.         InOutBase,
  20.         VT52;
  21. FROM Strings    IMPORT  String,         MaxChars,       Delete;
  22. FROM MOSGlobals IMPORT  MemArea;
  23. FROM ResCtrl    IMPORT  RemovalCarrier, CatchRemoval;
  24. FROM PrgCtrl    IMPORT  TermProcess;
  25. FROM StrConv    IMPORT  StrToLInt;
  26. FROM GrafBase   IMPORT  GetScreen;
  27.  
  28. (* ------------------------------------------------------------------------- *)
  29.  
  30. CONST
  31.   ConfirmClose = TRUE;   (* TRUE -> Bei Prg-Ende wird auf Taste gewartet *)
  32.   
  33.   MaxScreen    = 24L;
  34.   HalfMaxScreen= MaxScreen DIV 2L + 1L;
  35.   
  36.   ESC          = 33C;
  37.   LF           = 12C;
  38.   CR           = 15C;
  39.   BS           = 10C;
  40.   
  41.   MORE         = "- MORE -";
  42.   ENDE         = "- END -";
  43.   STEP         = "- STEP: ";
  44.   SMSG         = "- MORE: Output suppressed! -";
  45.  
  46. (* ------------------------------------------------------------------------- *)
  47.  
  48. TYPE
  49.   escState     = (normalEsc, escEsc, gotoXEsc, gotoYEsc);
  50.   escStateDesc = RECORD
  51.                    state  : escState;
  52.                    lnsave : LONGINT;
  53.                    revers : BOOLEAN;
  54.                    wrapon : BOOLEAN;
  55.                    numrow : CARDINAL;
  56.                  END;
  57.  
  58. (* ------------------------------------------------------------------------- *)
  59.  
  60. VAR ok         : BOOLEAN;
  61.     waitAtEnd  : BOOLEAN;
  62.     
  63.     lncount    : LONGINT;
  64.     rowcount   : CARDINAL;
  65.     terminated : BOOLEAN;
  66.     nullout    : BOOLEAN;
  67.     vt52       : escStateDesc;
  68.  
  69. (* ------------------------------------------------------------------------- *)
  70.  
  71. PROCEDURE reverseOn;
  72.   BEGIN
  73.     IF NOT vt52.revers THEN
  74.       Terminal.WriteString (VT52.Seq[VT52.reverseOn]);
  75.     END;
  76.   END reverseOn;
  77.   
  78. (* ------------------------------------------------------------------------- *)
  79.  
  80. PROCEDURE reverseOff;
  81.   BEGIN
  82.     IF NOT vt52.revers THEN
  83.       Terminal.WriteString (VT52.Seq[VT52.reverseOff]);
  84.     END;
  85.   END reverseOff;
  86.   
  87. (* ------------------------------------------------------------------------- *)
  88.  
  89. PROCEDURE NullScreen (on : BOOLEAN);
  90.   BEGIN
  91.     Terminal.WritePg;
  92.     IF on THEN
  93.       reverseOn;
  94.       Terminal.WriteString (VT52.GotoRowColSeq (12, vt52.numrow DIV 2 - 14));
  95.       Terminal.WriteString (SMSG);
  96.       reverseOff;
  97.       Terminal.WriteLn;
  98.       nullout := TRUE;
  99.       lncount := 1L;
  100.     ELSE
  101.       nullout := FALSE;
  102.       lncount := -MaxScreen;
  103.       rowcount := 0;
  104.     END;
  105.   END NullScreen;
  106.   
  107. (* ------------------------------------------------------------------------- *)
  108.  
  109. PROCEDURE ScreenOn;
  110.   BEGIN
  111.     NullScreen (FALSE);
  112.   END ScreenOn;
  113.   
  114. (* ------------------------------------------------------------------------- *)
  115.  
  116. PROCEDURE ScrollOff;
  117.   BEGIN
  118.     lncount := 1L;
  119.   END ScrollOff;
  120.   
  121. (* ------------------------------------------------------------------------- *)
  122.  
  123. PROCEDURE ScrollOn;
  124.   BEGIN
  125.     lncount := 0L;
  126.   END ScrollOn;
  127.  
  128. (* ------------------------------------------------------------------------- *)
  129.  
  130. PROCEDURE ScreenOff;
  131.   BEGIN
  132.     NullScreen (TRUE);
  133.   END ScreenOff;
  134.   
  135. (* ------------------------------------------------------------------------- *)
  136.  
  137. PROCEDURE clearLine;
  138.   BEGIN
  139.     Terminal.WriteString (VT52.Seq[VT52.clearLine]);
  140.     Terminal.WriteString (VT52.Seq[VT52.left]);
  141.   END clearLine;
  142.   
  143. (* ------------------------------------------------------------------------- *)
  144.  
  145. PROCEDURE More (REF s : ARRAY OF CHAR);
  146.  
  147.   (* Wird aufgerufen wenn ein LF aufgetreten ist. Falls 'lncount = 0' ist
  148.    * werden die MORE - Aktionen abgefragt.
  149.    *)
  150.  
  151.   VAR ch        : CHAR;
  152.       success   : BOOLEAN;
  153.       helpcount : CARDINAL;
  154.  
  155.   (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *)
  156.   
  157.   PROCEDURE setcount (c : CHAR) : LONGINT;
  158.     
  159.     (* Liest die Schrittweite für 'lncount' ein. Falls eine falsche Zahl
  160.      * eingegeben wurde, wird eine ganze Bildschirmseite weitergescrollt.
  161.      *)
  162.     VAR count   : LONGINT;
  163.         digits  : ARRAY [0..20] OF CHAR;
  164.         dpos    : CARDINAL;
  165.         valid   : BOOLEAN;
  166.     BEGIN
  167.       count := 0;                                         (* Initialisierung *)
  168.       dpos  := 0;
  169.       
  170.       reverseOn;
  171.       Terminal.WriteString (STEP);
  172.       
  173.       LOOP                                                (* Eingabeschleife *)
  174.         IF (c = BS) THEN
  175.           IF dpos > 0 THEN
  176.             Terminal.WriteString (VT52.Seq[VT52.left]);
  177.             Terminal.WriteString (VT52.Seq[VT52.clearEOL]);
  178.             DEC (dpos);
  179.           END;
  180.         ELSE
  181.           IF (c < '0') OR (c > '9') THEN EXIT; END;
  182.           IF dpos <= 20 THEN
  183.             digits[dpos] := c;   INC (dpos);
  184.             Terminal.Write (c);
  185.           END;
  186.         END;
  187.         Terminal.GetChar (c);
  188.       END;
  189.       IF dpos <= 20 THEN digits[dpos] := 0C; END;
  190.       
  191.       dpos := 0;                                       (* lncount bestimmen. *)
  192.       count := StrToLInt  (digits, dpos, valid);
  193.       IF valid THEN
  194.         CASE CAP (c) OF
  195.         | CR  : ;
  196.         | 'D' : IF count < MaxLInt DIV HalfMaxScreen THEN
  197.                   count := count * HalfMaxScreen;
  198.                 ELSE
  199.                   count := HalfMaxScreen;
  200.                 END;
  201.         ELSE
  202.           IF count < MaxLInt DIV MaxScreen THEN
  203.             count := count * (MaxScreen - 1L);
  204.           ELSE
  205.             count := MaxScreen - 1L;
  206.           END;
  207.         END;
  208.       ELSE
  209.         count := MaxScreen - 1L;
  210.       END;
  211.       
  212.       reverseOff;                                               (* Aufräumen *)
  213.       clearLine;
  214.       RETURN count;
  215.     END setcount;
  216.  
  217.   (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *)
  218.  
  219.   PROCEDURE checkkey (ch : CHAR) : BOOLEAN;
  220.     (*  Liefert 'TRUE' und konfiguriert 'More' entsprechend, wenn eine gültige
  221.      *  Kommandotaste gedrückt wurde.
  222.      *  'FALSE' in allen anderen Fällen.
  223.      *)
  224.     VAR valid : BOOLEAN;
  225.     BEGIN
  226.       valid := TRUE;
  227.       CASE CAP (ch) OF
  228.       | CR         : lncount := -1L;
  229.       | ESC        : NullScreen (TRUE);
  230.       | ' '        : lncount := - MaxScreen + 1L;
  231.       | 'D'        : lncount := - HalfMaxScreen;
  232.       | 'G'        : lncount := 0L;
  233.       | 'Q'        : IF NOT terminated THEN
  234.                        terminated := TRUE;
  235.                        waitAtEnd := FALSE;
  236.                        TermProcess (0);
  237.                      END;
  238.       | '0' .. '9' : lncount := - setcount (ch);
  239.       ELSE
  240.         valid := FALSE;
  241.       END;
  242.       RETURN valid;
  243.     END checkkey;
  244.     
  245.   (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *)
  246. (*
  247.                     0123456789012345678901234567890123456789
  248. *)
  249.   PROCEDURE Help (VAR count : CARDINAL) : CHAR;
  250.     CONST
  251.     NOHELP = " sorry! no help onthis screen! : ";
  252.     HELP1  = " valid keys: 0..9, RET, SPC, D, Q, G, ESC (other: more help): ";
  253.     HELP2  = " 0..9: repeat following command 'STEP' times! (more help): ";
  254.     HELP3  = " RET: scroll 'STEP' lines! (more help): ";
  255.     HELP4  = " SPC: scroll 'STEP' screens! (more help): ";
  256.     HELP5  = " D: scroll 'STEP' halfscreens! (more help): ";
  257.     HELP6  = " Q: terminate program! (more help): ";
  258.     HELP7  = " G: go-mode (scroll until any key pressed)! (more help): ";
  259.     HELP8  = " ESC: toggle screen on/off! (more help): ";
  260.     HELP9  = " (other): show help messages! (more info): ";
  261.     HELP0  = " Idea and realization by DIETER HAMETNER (West Germany, 1990): ";
  262.     VAR ch : CHAR;
  263.     BEGIN
  264.       reverseOn;
  265.       Terminal.WriteString (s);
  266.       IF (count > 0) THEN
  267.         IF vt52.numrow = 40 THEN
  268.           Terminal.WriteString (NOHELP);
  269.         ELSE
  270.           CASE count OF
  271.           |  1 : Terminal.WriteString (HELP1);
  272.           |  2 : Terminal.WriteString (HELP2);
  273.           |  3 : Terminal.WriteString (HELP3);
  274.           |  4 : Terminal.WriteString (HELP4);
  275.           |  5 : Terminal.WriteString (HELP5);
  276.           |  6 : Terminal.WriteString (HELP6);
  277.           |  7 : Terminal.WriteString (HELP7);
  278.           |  8 : Terminal.WriteString (HELP8);
  279.           |  9 : Terminal.WriteString (HELP9);
  280.           | 10 : Terminal.WriteString (HELP0);
  281.           ELSE
  282.           END;
  283.         END;
  284.       END;
  285.       Terminal.GetChar (ch);
  286.       reverseOff;
  287.       clearLine;
  288.       INC (count);
  289.       IF count = 11 THEN count := 0; END;
  290.       RETURN ch;
  291.     END Help;
  292.     
  293.   (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *)
  294.  
  295.   BEGIN
  296.     IF Terminal.KeyPressed () THEN
  297.       Terminal.GetChar (ch);
  298.       IF ch = ESC THEN
  299.         NullScreen (NOT nullout);
  300.         RETURN;
  301.       END;
  302.       IF lncount > 0L THEN
  303.         lncount := 0L;
  304.       END;
  305.     END;
  306.     IF lncount = 0L THEN
  307.       helpcount := 0;
  308.       REPEAT
  309.       UNTIL checkkey (CAP (Help (helpcount)));
  310.     END;
  311.   END More;
  312.  
  313. (* ------------------------------------------------------------------------- *)
  314.  
  315. PROCEDURE vt52Emul(c : CHAR);
  316.   
  317.   (* Wird aufgerufen falls 'vt52.state' # 'normalEsc' oder das aktuelle
  318.    * Zeichen 'c' = ESC ist. Diese Prozedur wertet die Escape-Sequenzen aus.
  319.    *)
  320.   BEGIN
  321.     WITH vt52 DO
  322.       CASE state OF
  323.       | normalEsc: IF c = ESC THEN state := escEsc; END;
  324.       | escEsc   : state := normalEsc;
  325.                    CASE c OF
  326.                    | 'A',
  327.                      'I' : IF lncount > -MaxScreen THEN
  328.                              DEC (lncount);
  329.                            END;
  330.                    | 'B' : IF lncount < 1L THEN
  331.                              INC (lncount);
  332.                            END;
  333.                    | 'E',
  334.                      'H' : lncount := -MaxScreen;
  335.                    | 'Y' : state := gotoYEsc;
  336.                    | 'j' : lnsave := lncount;
  337.                    | 'k' : lncount := lnsave;
  338.                    | 'p' : revers := TRUE;
  339.                    | 'q' : revers := FALSE;
  340.                    | 'v' : wrapon := TRUE;
  341.                    | 'w' : wrapon := FALSE;
  342.                    ELSE
  343.                    END;
  344.       | gotoXEsc : state := normalEsc;
  345.       | gotoYEsc : state := gotoXEsc;
  346.                    lncount := -MaxScreen + LONG (ORD (c) - 32);
  347.       END; (* CASE *)
  348.     END; (* WITH *)
  349.   END vt52Emul;
  350.   
  351. (* ------------------------------------------------------------------------- *)
  352.  
  353. PROCEDURE WriteLn;
  354.   BEGIN
  355.     IF NOT nullout THEN
  356.       Terminal.WriteLn;
  357.       INC (lncount); rowcount := 0;
  358.     END;
  359.     More (MORE);
  360.   END WriteLn;
  361.   
  362. (* ------------------------------------------------------------------------- *)
  363.  
  364. PROCEDURE Open (x,y: CARDINAL);
  365.   BEGIN
  366.     waitAtEnd:= FALSE;
  367.   END Open;
  368.  
  369. (* ------------------------------------------------------------------------- *)
  370.  
  371. PROCEDURE Close;
  372.   BEGIN
  373.     IF waitAtEnd & ConfirmClose THEN
  374.       (*
  375.        * Am Programmende auf Tastendruck warten,
  376.        * wenn zuletzt Ausgaben gemacht wurden, die sonst nicht mehr
  377.        * gesehen würden.
  378.        *)
  379.       terminated := TRUE;
  380.       waitAtEnd:= FALSE;
  381.       lncount := 0L;
  382.       More (ENDE);
  383.     END
  384.   END Close;
  385.  
  386. (* ------------------------------------------------------------------------- *)
  387.  
  388. PROCEDURE Read (VAR c: CHAR);
  389.   BEGIN
  390.     waitAtEnd:= FALSE;
  391.     IF nullout THEN NullScreen (FALSE) END;;
  392.     Terminal.Read (c);
  393.     IF c = CR THEN rowcount := 0; ELSE INC (rowcount); END;
  394.     IF vt52.wrapon AND (rowcount = vt52.numrow) THEN
  395.       rowcount := 0; INC (lncount); More (MORE);
  396.     END;
  397.   END Read;
  398.  
  399. (* ------------------------------------------------------------------------- *)
  400.  
  401. PROCEDURE Write (c: CHAR);
  402.   BEGIN
  403.     IF NOT nullout THEN
  404.       waitAtEnd:= TRUE;
  405.       Terminal.Write (c);
  406.       IF (vt52.state # normalEsc) OR (c = ESC) THEN vt52Emul (c); END;
  407.       IF c = CR THEN rowcount := 0; ELSE INC (rowcount); END;
  408.       IF c = LF THEN INC (lncount); More (MORE); END;
  409.       IF vt52.wrapon AND (rowcount = vt52.numrow) THEN
  410.         rowcount := 0; INC (lncount);
  411.       END;
  412.     END;
  413.     More (MORE);
  414.   END Write;
  415.  
  416. (* ------------------------------------------------------------------------- *)
  417.  
  418. PROCEDURE ReadString (VAR c:ARRAY OF CHAR);
  419.   BEGIN
  420.     waitAtEnd:= FALSE;
  421.     IF nullout THEN NullScreen (FALSE) END;;
  422.     Terminal.ReadString (c);
  423.     WriteLn;
  424.   END ReadString;
  425.  
  426. (* ------------------------------------------------------------------------- *)
  427.  
  428. PROCEDURE WriteString (REF s: ARRAY OF CHAR);
  429.   VAR str   : String;
  430.       idx   : CARDINAL; (* Position in 'str' *)
  431.       pos   : CARDINAL; (* Position in 's' *)
  432.       exit  : BOOLEAN;
  433.       ch    : CHAR;
  434.   BEGIN
  435.     IF NOT nullout THEN
  436.       waitAtEnd := TRUE;
  437.       pos       := 0;
  438.       LOOP
  439.         idx  := 0;
  440.         exit := FALSE;
  441.         LOOP
  442.           str[idx] := s[pos];
  443.           ch := s[pos];
  444.           INC (pos);
  445.           INC (idx);
  446.           CASE ch OF
  447.           | 0C  : exit := TRUE; EXIT;
  448.           | CR  : rowcount := 0;
  449.           | LF  : INC (lncount); EXIT;
  450.           | ESC : vt52Emul (ch);
  451.           ELSE
  452.             IF vt52.state # normalEsc THEN
  453.               vt52Emul (ch);
  454.               EXIT;                            (* String ausgeben            *)
  455.             END;
  456.             INC (rowcount);
  457.             IF vt52.wrapon AND (rowcount = vt52.numrow) THEN
  458.               rowcount := 0; INC (lncount);
  459.               ch := LF;                        (* Damit More aufgerufen wird *)
  460.               EXIT;                            (* String ausgeben            *)
  461.             END;
  462.           END;
  463.           IF idx > MaxChars THEN EXIT; END;    (* String ausgeben            *)
  464.           IF pos - 1 = HIGH (s) THEN
  465.             exit := TRUE;
  466.             EXIT;
  467.           END;
  468.         END;
  469.         IF idx <= MaxChars THEN
  470.           str[idx] := 0C;
  471.         END;
  472.         Terminal.WriteString (str);
  473.         IF (vt52.state = normalEsc) AND (ch = LF) THEN
  474.           More (MORE);
  475.         END;
  476.         IF exit THEN EXIT; END;                (* WriteString zu Ende!       *)
  477.       END;
  478.     ELSE
  479.       More (MORE);
  480.     END;
  481.   END WriteString;
  482.  
  483. (* ------------------------------------------------------------------------- *)
  484.  
  485. PROCEDURE GetInput ( VAR name: ARRAY OF CHAR );
  486.   BEGIN
  487.     ReadString (name);
  488.   END GetInput;
  489.  
  490. (* ------------------------------------------------------------------------- *)
  491.  
  492. PROCEDURE GetOutput ( VAR name: ARRAY OF CHAR; VAR append: BOOLEAN );
  493.   BEGIN
  494.     ReadString (name);
  495.     append:= name[0] = '>';
  496.     IF append THEN
  497.       Delete (name,0,1,ok)
  498.     END;
  499.   END GetOutput;
  500.  
  501. (* ------------------------------------------------------------------------- *)
  502.  
  503. PROCEDURE OpenError ( VAR msg: ARRAY OF CHAR; VAR retry: BOOLEAN );
  504.   VAR c: CHAR;
  505.   BEGIN
  506.     nullout := FALSE;
  507.     WriteLn;
  508.     WriteString ('Fehler beim Öffnen: ');
  509.     WriteString (msg);
  510.     WriteLn;
  511.     WriteString ('Nochmalige Eingabe ? (J/N) ');
  512.     REPEAT
  513.       Terminal.BusyRead (c);
  514.       c:= CAP (c)
  515.     UNTIL (c='J') OR (c='N');
  516.     retry:= c='J';
  517.     WriteLn;
  518.   END OpenError;
  519.  
  520. (* ------------------------------------------------------------------------- *)
  521.  
  522. PROCEDURE IOError ( VAR msg: ARRAY OF CHAR; input: BOOLEAN );
  523.   VAR c: CHAR;
  524.   BEGIN
  525.     nullout := FALSE;
  526.     WriteLn;
  527.     WriteString ('Fehler bei Datei');
  528.     IF input THEN
  529.       WriteString ('eingabe: ')
  530.     ELSE
  531.       WriteString ('ausgabe: ')
  532.     END;
  533.     WriteString (msg);
  534.     WriteLn;
  535.     WriteString ('Datei wird geschlossen. Bitte Taste drücken. ');
  536.     Terminal.FlushKbd;
  537.     REPEAT
  538.       Terminal.BusyRead (c);
  539.     UNTIL c#0C;
  540.     WriteLn;
  541.   END IOError;
  542.  
  543. (* ------------------------------------------------------------------------- *)
  544.  
  545. VAR pbuf: ARRAY [0..14] OF LONGWORD; pidx: CARDINAL;
  546.  
  547. PROCEDURE pset (f:BOOLEAN);
  548.   PROCEDURE pswap (VAR l:LONGWORD; v:LONGWORD);
  549.     (*$R+*)
  550.     BEGIN
  551.       IF f THEN pbuf [pidx]:= l; l:= v ELSE l:= pbuf [pidx] END;
  552.       INC (pidx)
  553.     END pswap;
  554.     (*$R=*)
  555.   BEGIN
  556.     pidx:= 0;
  557.     pswap (InOutBase.Read, ADDRESS (Read));
  558.     pswap (InOutBase.Write, ADDRESS (Write));
  559.     pswap (InOutBase.OpenWdw, ADDRESS (Open));
  560.     pswap (InOutBase.CloseWdw, ADDRESS (Close));
  561.     pswap (InOutBase.KeyPressed, ADDRESS (Terminal.KeyPressed));
  562.     pswap (InOutBase.CondRead, ADDRESS (Terminal.CondRead));
  563.     pswap (InOutBase.WriteLn, ADDRESS (WriteLn));
  564.     pswap (InOutBase.WritePg, ADDRESS (Terminal.WritePg));
  565.     pswap (InOutBase.WriteString, ADDRESS (WriteString));
  566.     pswap (InOutBase.ReadString, ADDRESS (ReadString));
  567.     pswap (InOutBase.GotoXY, ADDRESS (Terminal.GotoXY));
  568.     pswap (InOutBase.GetInput, ADDRESS (GetInput));
  569.     pswap (InOutBase.GetOutput, ADDRESS (GetOutput));
  570.     pswap (InOutBase.OpenError, ADDRESS (OpenError));
  571.     pswap (InOutBase.IOError, ADDRESS (IOError));
  572.   END pset;
  573.  
  574. (* ------------------------------------------------------------------------- *)
  575.  
  576. PROCEDURE restore;
  577.   BEGIN
  578.     pset (FALSE) (* Wiederherstellen der alten PROC-Werte *)
  579.   END restore;
  580.  
  581. (* ------------------------------------------------------------------------- *)
  582.  
  583. VAR tc        : RemovalCarrier;
  584.     st        : MemArea;
  585.     phys, log : ADDRESS;
  586.     rez       : INTEGER;
  587. BEGIN
  588.   CatchRemoval (tc, restore, st);
  589.   pset (TRUE);  (* Retten der alten PROC-Werte und Setzen der Neuen *)
  590.   nullout     := FALSE;
  591.   lncount     := -MaxScreen;
  592.   rowcount    := 0;
  593.   terminated  := FALSE;
  594.   vt52.state  := normalEsc;
  595.   vt52.lnsave := lncount;
  596.   vt52.revers := FALSE;
  597.   vt52.wrapon := TRUE;                      (* nach Einschalten des Rechners *)
  598.   GetScreen (log, phys, rez);
  599.   IF rez = 0 THEN
  600.     vt52.numrow := 40;
  601.   ELSE
  602.     vt52.numrow := 80;
  603.   END;
  604. END MoreIO.
  605.